home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Libris Britannia 4
/
science library(b).zip
/
science library(b)
/
PROGRAMM
/
PROGEDIT
/
3943.ZIP
/
EVOLV201.ZIP
/
EVOLVE.DOC
< prev
next >
Wrap
Text File
|
1993-07-21
|
75KB
|
1,897 lines
EVOLVE!
Copyright (C) Richard H. Smith, 1993 All Rights Reserved.
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Why programmers need to use EVOLVE!. . . . . . . . . . . . . . . . . . . 3
What is source code maintenance? . . . . . . . . . . . . . . . . . . . . 3
What do programmers need to maintain source code? . . . . . . . . . 4
How EVOLVE! empowers programmers to maintain source
code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
What is EVOLVE!'s relation to source code
maintenance?. . . . . . . . . . . . . . . . . . . . . . . 5
How the report function transforms an outline into
source code . . . . . . . . . . . . . . . . . . . . . . . 5
"<^>" . . . . . . . . . . . . . . . . . . . . . . . . . . 6
":>". . . . . . . . . . . . . . . . . . . . . . . . . . . 6
How to explicitly define a structure . . . . . . . . . . . . . 6
Using ":>" and "<^>" together . . . . . . . . . . . . . . 8
How to use EVOLVE! . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
The user interface. . . . . . . . . . . . . . . . . . . . . . . . . 10
The menu bar and menus . . . . . . . . . . . . . . . . . . . . 10
Shortcuts. . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
The status line. . . . . . . . . . . . . . . . . . . . . . . . 11
Dialog boxes . . . . . . . . . . . . . . . . . . . . . . . . . 11
How to transform a source code file into an outline that
explicitly defines the structure of the program. . . . . . . . 12
EVOLVE!'s Script Programming Language . . . . . . . . . . . . . . . 14
Command Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Menu structure. . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Description of commands . . . . . . . . . . . . . . . . . . . . . . 22
Menu items sorted by hotkey. . . . . . . . . . . . . . . . . . 33
License Agreement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Definition of Shareware . . . . . . . . . . . . . . . . . . . . . . 35
Disclaimer - Agreement. . . . . . . . . . . . . . . . . . . . . . . 35
Benefits of registering . . . . . . . . . . . . . . . . . . . . . . 36
How To Register . . . . . . . . . . . . . . . . . . . . . . . . . . 37
ASP Ombudsman Statement. . . . . . . . . . . . . . . . . . . . . . . . . 39
About the Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Introduction
Mathematicians, and other technical people, sometimes talk about an
abstract but simple concept they call a 'graph.' This kind of graph
is independent of any particular visual representation. We can
represent one graph an infinite number of ways. A graph is simply
a set of nodes and edges. Each edge is a directed association of
two nodes: an edge connects from one node to another node.
Sometimes these graphs are called 'nets' or 'networks.'
We can represent any information as a graph. In particular, a
computer program's source code specifies a graph, and the compiler
constructs that graph while parsing the source code. Graphs are
fundamental to the way computers process information. Any
information that has a structure is an example of a graph.
EVOLVE! is a graph tool. It can edit graphs, generate an ASCII file
that specifies the graph, and execute its own graph programming
language. The report function of EVOLVE! can generate a graph
specification in a wide range of grammars. Remember, every program
is a graph specification. I use EVOLVE! to represent parts of
itself as a graph, and generate its own source code in Borland
Pascal. EVOLVE! facilitates developing and maintaining source code
in any language. It will enable a programmer to design a program
such that he can efficiently implement changes, much like a
programmer can use constants and macros to improve the
maintainability of source code. However, EVOLVE! presents the
program in a more visual (rather than verbal) way that most people
find more readable. EVOLVE! also enables users to dynamically
inspect and modify a program's structure. The rest of this chapter
will explain how EVOLVE! displays graphs.
I need to use some trivial and meaningless example of a graph to
clearly explain how to best display them on a computer screen. The
example graph is 5 nodes {A,B,C,D,E} and 7 edges
{AB,AC,AD,BE,CE,DE,EA}. The previous sentence represented the graph
one way by just listing the nodes and edges. In figure 1 is another
representation of the graph, where each node is represented by its
name (e.g. a letter) and each edge is represented by a line.
┌── >B ───┐
│ v
┌── >A ─ >C ─ >E ─┐
│ │ ^ │
│ └── >D ───┘ │
│ │
└─────────────────┘
Figure 1 An example graph
You will usually see graphs represented by a drawing where each node
is represented by an ellipse or polygon containing a node identifier
and each edge is represented with a line. This is an effective
format for representing a graph on paper. We can display even large
graphs this way because large pieces of paper are inexpensive and
easy to acquire.
Imagine what would happen if we needed to show more text inside of
each node. Or what if we had hundreds of nodes instead of five? We
would need a lot of area to show a representation of this kind that
was readable. This works well on paper, because you can get big
pieces of paper. It does not work as well on a computer display,
because they are usually only about a half page big.
Some would argue that by using a scrollable window, a computer can
display a large graph one small rectangle at a time. Personally, I
find it difficult to take in a large graph when I can only see a
small part of it at once. To clearly display large graphs on a
computer screen, we need a representation that frugally uses space.
The representation shown in the figure above has a lot of unused
spaced that is aesthetically pleasing but communicates little
information.
The representation I prefer to use is that of a text outline. Below
is our example graph represented as a text outline
A
1. B
1. E
1. A
2. C
1. E
3. D
1. E
With this format, the node 'A' is listed as a child of 'E' only
once because listing it under every appearance of 'E' would be
redundant. Note that we have a lot of room to the right of each
node to display a full line of text. The text outline format above
has one problem: how can we know that the 'E's and 'A's are the same
node, or distinct nodes with identical names? One solution some
graph representations use is to insist that each node have a unique
name. EVOLVE! does not implement this solution. Instead, EVOLVE!
displays a unique identifying number for each node that appears more
than once. Below is how EVOLVE! could display this example graph.
A {123456789:3}
1. B
1. E {123456780:1}
1. A {123456789:3}
2. C
1. E {123456780:1}
3. D
1. E {123456780:1}
The curly brackets contain two numbers separated by a colon. The
first number is a unique identifier. The second number is the
number of edges that originate from that node. The edge from 'E' to
'A' is only represented once, but every image of 'E' indicates that
there is one edge originating from it with the ':1}'.
EVOLVE! is a graph tool that represents graphs as text outlines.
EVOLVE! is also a source code maintenance tool because source code
is a graph representation, and EVOLVE! has capabilities for
transforming graphs between the source code representation and the
text outline representation.
Chapter 2 explains why programmers need to use EVOLVE!. Chapter 3
explains how to use EVOLVE!. Chapter 4 is a reference section for
EVOLVE!.
Why programmers need to use EVOLVE!
Programmers need to use EVOLVE! for two reasons. First, proper use
of EVOLVE! will minimize the keystrokes and decisions required to
make source code changes. Second, programmers can use EVOLVE! to
clarify their understanding of the consequences of source code
changes.
This chapter provides the information a user needs to understand
what EVOLVE! is and what requirements it fulfills. This chapter's
first section is a definition of source code maintenance. The
second section describes the capabilities a programmer needs to
maintain source code. The third section describes the tools, other
than EVOLVE!, available for facilitating source code maintenance.
The fourth section explains the source code maintenance capabilities
that only EVOLVE! provides.
What is source code maintenance?
Source code maintenance is closely related to, but not equivalent
to, software maintenance. Richard E. Fairley defines in his book
"Software Engineering" software maintenance as "the software
engineering activities that occur following delivery of a software
product to a customer." This could include making changes to the
software that do not involve changing the source code. You could
produce a new version of an executable program by simply using a
different compiler. Also, some instances of source code maintenance
are not software maintenance. For example, a programmer may change
a comment that was in error. If the comment does not affect any
deliverables to the client, this modification is source code
maintenance but not software maintenance. However, to the
programmer who writes source code, software maintenance usually
means changing the source code.
The problem with the term "source code maintenance" is that it is
not maintenance in the traditional sense. Traditionally,
maintenance means restoring something that is worn out. Software
does not wear out. The American Heritage Dictionary defines
maintenance as "The action of continuing, carrying on, preserving,
or retaining something." This does not describe what I think of as
source code maintenance, unless the thing that source code
maintenance continues, preserves, and maintains is the customer's
satisfaction. Whether the software has been delivered to the
customer makes no difference to the technical challenge of changing
the source in an appropriate manner. Therefore, I define source
code maintenance as the process of evolving software by implementing
appropriate incremental changes. This process of evolving source
code may occur during the development phase.
Since we know that software does not wear out, we should consider
why programmers need to change source code. There are three types
of reasons programmers change source code. First, programmers need
to correct problems. Second, the requirements for the program may
change. Third, the development strategy may be based on
incrementally evolving the program. The point here is that
programmers make incremental changes to source code in software
development as well as software maintenance.
What do programmers need to maintain source code?
Programmers need the following abilities to facilitate the safe and
correct maintenance of source code.
1. The capability to modify the source code with a minimum of
keystrokes and decisions. This reduces the probability a
programmer will introduce new errors when he makes a
modification. For example, programmers use named constants so
that they can redefine the constant and re-compile and the
compiler will implement the new value everywhere that constant
is used.
2. The capability to encapsulate areas of the source code to
avoid unintended side effects.
3. The ability to inspect the code and data structures to see
the consequences of changes they are considering.
How EVOLVE! empowers programmers to maintain source code
EVOLVE! lets users program down to the lowest level of detail with
a structure editor. It enables users to change and dynamically
inspect a program's structure. When a programmer uses EVOLVE! to
explicitly define the programs structure, she has at her disposal
hypertext like links she can use to inspect the source code.
This section answers the following questions:
1. What is EVOLVE!'s relation to source code maintenance?
2. How does the report function transform an outline into
source code?
3. How can a programmer use EVOLVE! to explicitly represent the
structure of a program as an outline?
What is EVOLVE!'s relation to source code maintenance?
EVOLVE! is in one way the complement of source code. Source code is
always a sequence of symbols that define a structure. The structure
defined by source code includes data structures, machine
instructions, compiler directives, and comments to the reader of the
source code. EVOLVE! is a structure editor that produces source
code. It enables you to edit the structure as a hierarchy (a.k.a.
outline), and produce source code from that hierarchy. Although
EVOLVE! displays the program as an outline while a user edits it, he
can press a key to instantly view the program as source code.
When programmers use a text editor to create and modify a source
code file, they use the syntax of the language and the
identifiers they create to specify a structure that the compiler
will understand and process into machine language. When a
programmer uses EVOLVE!, he explicitly defines a structure
(visually represented on the screen as an outline) that the EVOLVE!
program processes to produce a text file of source code that
specifies the explicitly defined structure. If the programmer
creates a structure with EVOLVE!, he can use this structure to
perform the following source code maintenance functions:
1. Efficiently implement changes without introducing new
errors.
2. Dynamically inspect the structure of the code to evaluate
the consequences of possible modifications.
How the report function transforms an outline into source code
The report command under the files menu will generate source code
from an outline by processing two special strings. The first string
is "<^>" and the second string is ":>". Programmers use the ":>"
string to define the syntactic structure and the "<^>" string to
define part of the semantic structure.
"<^>"
When a user chooses to produce a report, EVOLVE! processes the "<^>"
string first by replacing each one with the text from a subsidiary
line in the outline. Below is an example of how the report function
processes "<^>":
The <^> is <^>.
car
green
The end.
The outline above would produce the following report:
The car is green.
The end.
Notice that EVOLVE! accounts for how many subsidiary lines were used
to replace "<^>", and processes the rest.
":>"
The ":>" string is used to define delimiters. Many programming
languages will use a comma or semicolon in between items in a list,
and a special string to mark the end like '}', ')', or 'end'. You
can use ":>" twice in one line: first to specify the in between
delimiter and second occurrence of ":>" to define the ending
delimiter. Below is an example:
MyFunc(:>,:>)
aaa
bbb
ccc
The outline above would produce the following report:
MyFunc(
aaa,
bbb,
ccc)
How to explicitly define a structure
Users will want to create an outline where an identifier appears in
more than one place. The best way to do this is to place each
identifier on a separate line and use '<^>' to place the identifier
in the "parent" line of the outline. The reason users should place
each identifier on a separate line is that they can reference a
line. Users should not simply retype or copy identifiers because
that creates new instances of the identifier. The new line created
by a copy is distinct from the originals. The "mark" and
"reference" commands enable users to create another appearance of a
line, where both the original appearance and the new appearance
refer to the same instance of the line. When a user makes a change
to a line that appears in more than one place (because it is
referenced) the change is implemented at all locations. A user can
create a new appearance of a line by:
1. If any lines are already marked, press [Alt-U] to unmark all
lines.
2. "mark" the line(s).
3. move the cursor to the parent of the new appearance(s).
4. press [Alt-=] to "reference" the marked line(s).
There are three ways to mark a line:
1. Users can mark an unmarked line and unmark a marked line by
double clicking the left mouse button.
2. Users can mark the next (or previous) line with a specified
substring. The command for this is named "Mark if found" and
its hot key is [Ctrl-F6].
3. Users can position the cursor on a line and press
[Alt-Space] to mark an unmarked line and unmark a marked line.
Appearances of a referenced line identify themselves by displaying
a unique number, followed by the number of children they have. It
looks like this:
a referenced line {1234567890:5}
If she references an identifier where it makes sense, she will
benefit in the following ways:
1. She can use the "Go to parent" command [F7] to see a list of
everywhere that identifier is used in the source code.
2. Any change he makes to one appearance of an identifier is
implemented at all appearances of that identifier.
Using ":>" and "<^>" together
Below is an example Pascal program that reads two numbers and prints
out their product:
Program MultiplyTwo;
{This program reads in two numbers and prints the product}
Var
FirstNumber : Integer {The first number};
SecondNumber : Integer {The second number};
MyResult : Integer {The answer};
Function MultiplyTwoNumbers(OneNumber : Integer;AnotherNumber :
Integer) : Integer;
begin
MultiplyTwoNumbers :=
OneNumber *
AnotherNumber;
end;
begin
readln(
FirstNumber,
SecondNumber);
MyResult := MultiplyTwoNumbers(
FirstNumber,
SecondNumber);
writeln(
'The first: ',
FirstNumber,
' The Second: ',
SecondNumber,
' The Product: ',
MyResult);
end.
EVOLVE! will generate this program source code from the following
outline:
Program MultiplyTwo;:>;:>.
{<^>}
This program reads in two numbers and prints the product
Var:>;
<^> : <^> {The first number}
FirstNumber {18269:0}
Integer {18274:0}
<^> : <^> {The second number}
SecondNumber {18287:0}
Integer {18274:0}
<^> : <^> {The answer}
MyResult {18302:0}
Integer {18274:0}
Function <^>(<^>;<^>) : <^>;
MultiplyTwoNumbers {18318:0}
<^> : <^>
OneNumber {18331:0}
Integer {18274:0}
<^> : <^>
AnotherNumber {18346:0}
Integer {18274:0}
Integer {18274:0}
begin:>;:>end
<^> := :> *
MultiplyTwoNumbers {18318:0}
OneNumber {18331:0}
AnotherNumber {18346:0}
begin:>;:>end
readln(:>,:>)
FirstNumber {18269:0}
SecondNumber {18287:0}
<^> := <^>(:>,:>)
MyResult {18302:0}
MultiplyTwoNumbers {18318:0}
FirstNumber {18269:0}
SecondNumber {18287:0}
writeln(:>,:>)
'The first: '
FirstNumber {18269:0}
' The Second: '
SecondNumber {18287:0}
' The Product: '
MyResult {18302:0}
The above outline explicitly defines the structure of the program.
When a programmer, using EVOLVE!, has an outline with an explicitly
defined structure he can efficiently manage the source code changes.
He can also use the outline to dynamically inspect the program's
structure to evaluate the consequences of possible changes.
The reader should not let the size of the above outline mislead him
to think that it takes more keystrokes to build the outline than to
type the source code. The "Marking" commands let users reference an
identifier with fewer keystrokes than it takes to type it.
To summarize this section, EVOLVE! is a source code structure
editor. The user can "mark" and "reference" identifiers to
explicitly define part of the semantic structure. The user can
define the rest of the semantic structure with the "<^>"
character. When the user invokes the "report" function, EVOLVE!
replaces each "<^>" with the text of a child in the outline. The
user can define some of the syntactic structure with the ":>"
string. Together, the syntactic and semantic structures comprise
the structure of the program's source code. EVOLVE! enables users
to explore and edit a program's structure explicitly and
dynamically.
How to use EVOLVE!
This chapter explains how to use EVOLVE!. The first section
describes general features of the user interface. The second
section gives an example of how to transform a source code file
into an outline. The third section explains the macro-programming
language.
The user interface
EVOLVE!'s user interface has the general features common to most
modern software programs. These general features are pull down
menus, shortcuts, windows, status line, and dialog boxes.
The menu bar and menus
The menu bar is your primary access to all the menu commands.
You'll see a highlighted menu title when the menu bar is active;
this is the currently selected menu. Here is how you choose menu
commands using just the keyboard:
1. Press [F10]. This makes the menu bar active.
2. Use the arrow keys to select a sub-menu to display. Then press
[Enter].
As a shortcut to this step, a user can just press the highlighted
letter of the sub-menu title. For example, from the menu bar,
press [F] to quickly display the file menu. From anywhere, press
[Alt] and the highlighted letter to display the menu you want.
3. Use the arrow keys again to select the command desired. Then
press [Enter].
Again, as a shortcut, users can just press the highlighted letter
of a command to choose it once the menu is displayed.
At this point, EVOLVE! either carries out the command, displays a
dialog box, or displays another menu.
Shortcuts
A user can access many items in the menus with key combinations
called shortcuts. These key combinations are shown to the right
of the menu item in the menu boxes, and to the left of the command
in the status line. On page 33 there begins a list of menu items
and their associated shortcuts. This list is sorted by shortcut
key.
Windows
Windows in EVOLVE! have the following:
1. A title at the center of the top border. The title is the
name of the file associated with the window.
2. A window number. You can quickly select a window by
pressing [Alt] and the number of the window.
3. Horizontal and vertical scroll bars to show you the
location of your view into a virtual screen.
4. A position indicator at the left of the lower window
border that displays the row and column of the cursor.
5. A 'splat' character that appears to the left of the
position indicator when you have changed the program since
the last save.
The status line
The status line appears at the bottom of the screen. It reminds
you of basic keystrokes and shortcuts applicable at that moment in
the active window.
Dialog boxes
When a user is making settings in dialog boxes, they work with
four basic types of on-screen controls: radio buttons, action
buttons, input boxes, and list boxes.
Users can use [Tab] to select the next control in the dialog box
and [Shift-Tab] to select the previous control in the dialog.
Most controls have labels with one letter highlighted. Users can
select a control object by pressing [Alt] and the highlighted
letter. Users can close the dialog box by either selecting the
"OK" button to accept the data in the box and press [Enter], or
cancel any action by the box by pressing [Escape] or selecting a
"Cancel" button and pressing return.
Radio buttons work like the buttons on a radio; they represent
mutually exclusive choices. Use [Tab] or [Shift-Tab] to select
the group of radio buttons. Then select the item you want with
the up and down arrow keys and press [Space] to toggle that item.
Toggling a radio button untoggles the previously toggled button.
Input boxes are fields where text is entered and edited.
Most basic text editing keys work in the text box. If an input
box has a down-arrow icon to its right, there is a history list
associated with the input box. Press [Down Arrow] to view the
history list and enter to select an item from the list. This
list will display any text you typed into the box the last few
times you used it. Users can edit any item in the history list.
Press [Escape] to exit the history list without making a
selection.
A final component of many dialog boxes is a list box. A list box
lets you scroll through and select from variable-length lists
without leaving a dialog box. If a blinking cursor appears in the
list box and the user knows what he is looking for, he can type
the first letters of the text and the listbox will search for it.
He can move through the list with [Up Arrow] and [Down Arrow].
How to transform a source code file into an outline that
explicitly defines the structure of the program
This section is an example of how to transform the source code of
a program into an outline in EVOLVE!.
1. Press return at the opening screen to get rid of it.
2. Press [Ctrl-F8] to import an ASCII file.
3. Select the name of a file already on the disk.
4. Press [F9] to save the outline as a file with a different
extension, preferably ".MNT".
5. Press [Alt-X] to exit.
A programmer should be able to produce source code from this
outline now by pressing [Ctrl-F7], which invokes the report to
file function.
The outline as it stands now does not explicitly define the
structure of the program. You can transform the outline into an
explicit representation of the source code structure through a
range of strategies. This range of strategies is bounded by two
extremes: all at once, or as needed.
This section first discusses defining the semantic structure
explicitly, and then defining the syntactic structure explicitly.
An explicitly defined semantic structure will enable users to gain
the full utility of the "Go to parent" command, [F7]. This
command will let you see all the lines of source code that use a
given identifier.
The all at once strategy, for the semantic structure, is to
start at the top of the outline and perform the
"Search,Extract,Mark/Reference" command for each identifier. This
command is found in the "Marking" menu.
The step above specifies a lot of work if the user chooses to
transform the outline all at once. However, there is another
strategy that may be more practical for some cases. A programmer
can transform the outline a little at a time as he needs it. When
he has to make a source code modification, he performs the steps
specified above, but only for the identifiers relevant to the
source code modification.
An explicitly defined syntactic structure is useful, but not as
useful as an explicitly defined semantic structure. The syntactic
structure is defined with the ":>" string. Languages like C and
Pascal use special syntax to delimit lists of things. In Pascal,
each invocation of a function that takes parameters must include a
list of parameters to pass to that function. This list of
parameters in the invocation begins with a left parenthesis, ends
with a right parenthesis, and separates each item in the list with
a comma. I do not recommend a programmer explicitly define the
syntactic structure of a function call with ":>" if it is fully
contained in one line of text. However, there are some cases
where function calls are nested to form a hierarchy. Some user
interface tools encourage programmers to define menu structures
this ways. The syntax can get difficult to manage. A programmer
can use the ":>" string most efficiently for that case. I suggest
programmers start at the deepest levels of the outline and look
for places they can extract the syntax to the parent line.
In short, the way to transform a source code file is to import it
as an ASCII file, then use the 'Search, Extract, Mark/Reference'
command on identifiers.
EVOLVE!'s Script Programming Language
Sometimes a users finds herself performing a similar sequence of
commands through the use of menus or hotkeys. Users can sometimes
automate these sequences of commands by using a script program.
These scripts are outlines themselves, where each line is either a
script command, an expression, or a data item. You can execute
any part of an outline as a script by placing the cursor on the
first line of the script and pressing [Alt-F10].
Most of the menu items that operate within the context of just one
window have an equivalent script command. For example, the 'Move
cursor' menu has an item 'to first line' that performs the same
function as the script command 'cmFirstLine'. Another example is
the 'Go to line number' menu item which is equivalent to the
script command 'cmGoToLine'. This script command looks for the
line number in the first child of its line. All the script
commands that are similar to menu items are outline script
commands. This user's guide explains each outline script command
with its corresponding menu item in the user interface reference.
EVOLVE! augments the power of the outline script commands with
data flow script commands and control flow script commands. Data
flow script commands evaluate expressions and move the result to
other lines. Control flow commands control the sequence in which
EVOLVE! executes the script commands.
The data flow commands are:
cmMoveOutlineData
cmMoveOutlineNumber
cmMoveProgramData
cmMoveProgramNumber
cmMoveProgram2Outline
The cmMoveOutlineData and cmMoveOutlineNumber act on the outline
with out affecting the script as it is currently executing. When
you execute part of an outline as a script, EVOLVE! first makes a
copy of the script so any changes the script makes to the outline
will not accidentally interfere with the script. This copy is
executed as the script program and deleted at the end of the
script's execution. At the moment of replication, the script's
current instruction corresponds to the outline's current line.
However, after replication the script and the outline are
separate and independent. Thus, we can write script's that safely
alter the outline without accidentally interfering with the
script's execution.
These 'cmMoveOutline...' commands act on the children of the
current line in the outline. They take information from the first
child and pass the information to all other children of the
current line. Likewise, the cmMoveProgramNumber and
cmMoveProgramData affect the script that is currently executing,
and will not affect the outline. These commands act on the
children of the current instruction in the script. They both
transfer data from the first child of the current instruction to
all other children of the current instruction. The
cmMoveProgram2Outline command transfers data from the current
instruction to the outline's current line.
The commands that end with the word 'Number' evaluate the first
child as a real number expression. A real number expression is
simply a real number or an expression that produces a real number.
Below is a list of expression that produce a real number.
+ Sum all children of the this script line
- Negate and sum all children of this script line
/ divide the first child of this script line by the
product of all other children
* multiply all children of this script line
? the position of the outline's current line among its
siblings, less one. If the outline's current line is
the first child of its parent, it returns 0. If the
outline's current line is the second child of its
parent, it returns 1. Etc...
# the number of children under the outline's current line
<=> compares the first two children of this script line as
numeric expressions.
Result Meaning
=============================================
1 First child is less than second
2 First and second child are equal
3 Second child is less than the first child
4 There is an error
== This test to see if all the children of the outline's
current line are references of the same line. If two
lines are references of the same line they will have the
same two numbers inside of curly brackets to the right
of their text.
Result Meaning
====================
1 all reference the same line
2 not all the same
3 Error
= test to see if the text in each child of this script
line the are all equal
Result Meaning
=============================================
1 First child is less than second
2 First and second child are equal
3 Second child is less than the first child
4 There is an error
The commands that end with the word 'data' process the first child
as a text expression. A text expression is simply a line of text
or an expression that produces a line of text. Each occurrence of
the string <^> is replaced with the text produced by a child. The
first occurrence is replaced by the text produced by the first
child. The second occurrence is replaced by the text produced
from the second child, and so forth.
Example 1 of cmMoveOultineData:
Before execution
cmMoveOutlineData This is the first line, place cursor here
1. Hello world.
2.
After execution
cmMoveOutlineData This is the first line, place cursor here
1. Hello world.
2. Hello world.
Example 2 of cmMoveOutlineData with a text expression
Before execution
cmMoveOutlineData
1. <^> <^>.
1. Hello
2. world
2.
After execution
cmMoveOutlineData
1. <^> <^>.
1. Hello
2. world
2. Hello world.
Example 3 cmMoveOutlineNumber
Before execution
cmMoveOutlineNumber
1. 5.5
2.
After execution
cmMoveOutlineNumber
1. 5.5
2. 5.5000000000E+00
Example 4 cmMoveOutlineNumber with an expression
Before execution
cmMoveOutlineNumber
1. +
1. 2.3
2. 3.2
2.
After execution
cmMoveOutlineNumber
1. +
1. 2.3
2. 3.2
2. 5.5000000000E+00
The cmMoveProgramData and cmMoveProgramNumber commands are similar
but they do not affect the outline. These commands perform
similar functions on the script program.
The command cmMoveProgram2Outline will evaluate the first child of
the current instruction as a text expression, and set the current
line in the outline to that result.
The control flow commands are: DoAll, DoOne, Loop, and Pop.
DoAll will execute each child of the current instruction as a
command.
DoOne will evaluate the first child of the current instruction as
an expression that produces a number. The result of the first
child of the current instruction indicates which child, if any,
will succeed it as the current instruction. The Nth child of
DoOne is executed if N is the lowest upper bound of the numeric
result from the first child. If the first child is the value 5
then the sixth child will execute next. After the sixth child
executes, the next instruction will be the sibling following the
DoOne command. In other words, the script will not execute more
than one child of a DoOne instruction.
Loop, like DoAll, will execute each child as a command. In
addition, Loop will repeat itself by starting with the first child
again after the last child is executed.
The only way to stop the Loop cycle is with a Pop command. Pop
will exit out of the current Loop. Pop will also exit out of a
DoAll. When Loop's and DoAll's are nested, Pop will exit out of
the last DoAll or Loop that the EVOLVE! script is still
processing.
The user can execute any part of an outline as a script by placing
the cursor on the first line of the script and pressing [Alt-F10].
Each line in the script can be one command or data item. Any text
to the right of a script command in a line is ignored, so we may
use this space to place comments. A script command can be a
control flow command, data flow command, or an outline command.
The control flow commands direct the order in which script
instructions take their turn as the current instruction. Data
Flow commands move information through the outline and the script.
The outline script commands act on the outline, and they
correspond to a similar menu command. The script outline commands
are a subset of the commands available through the EVOLVE! menu.
The reference section documents each script outline command with
its corresponding menu item.
The following examples use the data flow, control flow and outline
commands listed in this chapter.
Before execution
Example 7
`-DoAll add lines with numbers in them
`-Loop through this
|-DoOne
| |-<=>
| | |-0 count {48173600:0}
| | `-5
| |-cmAddSibling makes a new blank line below this script
| `-Pop out of this loop
|-cmMoveProgramNumber This increments the loop counter
| |-+
| | |-1
| | `-0 count {48173600:0}
| `-0 count {48173600:0}
`-cmProgram2Outline sends the value of count to new line
`-0 count {48173600:0}
After execution
Example 7
|-DoAll add lines with numbers in them
| `-Loop through this
| |-DoOne
| | |-<=>
| | | |-0 count {48173600:0}
| | | `-5
| | |-cmAddSibling makes a new blank line below this script
| | `-Pop out of this loop
| |-cmMoveProgramNumber This increments the loop counter
| | |-+
| | | |-1
| | | `-0 count {48173600:0}
| | `-0 count {48173600:0}
| `-cmProgram2Outline sends the value of count to new line
| `-0 count {48173600:0}
|- 1.0000000000E+00
|- 2.0000000000E+00
|- 3.0000000000E+00
|- 4.0000000000E+00
`- 5.0000000000E+00
Command Reference
A user can select any menu item he sees displayed at the top of
the screen by holding down [Alt] key and the highlighted letter in
the menu choice. If the menu is active, don't use [Alt], just use
the highlighted letter. A user can activate the main menu by
pressing [F10]. Also, he can press [Alt-F] or [Alt-R] or [Alt-M]
or [Alt-E] or [Alt-W] or [Alt-A] to activate the main menu and the
associated submenu. Many commands lead to dialog boxes. When
these dialog buttons come up, they usually have the "cancel"
option highlighted. If a user presses return, the box will go
away and no changes will be made. If a user wants to do something
in a dialog box, he can press [Tab] to move to the first object in
the box. Likewise, [Shift-Tab] will move him to the previous
object in the box.
Menu structure
The Menu Structure is:
Menus [F10]
I. File [Alt-F]
A. Open [F3]
B. Save [F2]
C. Save As [F9]
D. Change Directory [Shift-F9]
E. Print [Ctrl-PrtScr]
F. Print to File [Shift-F7]
G. Report to File [Ctrl-F7]
H. Import ASCII File [Ctrl-F8]
I. Dos Shell
I. Exit [Alt-X]
II. Relocate Items [Alt-R]
A. Line to clipboard [Shift-F1]
B. Tree to clipboard [Ctrl-F1]
C. Line from clipboard [Shift-F2]
D. Tree from clipboard [Ctrl-F2]
E. Marked Lines to under current [Shift-F3]
F. Tree left a level [Ctrl-Left]
G. Tree right a level [Ctrl-Right]
H. Tree up [Ctrl-PgUp]
I. Tree Down [Ctrl-PgDn]
J. Sort
1. Ascending Grey-Plus
2. Descending Grey-Minus
III. Move Cursor [Alt-M]
A. to child [F4]
B. to parent [F7]
C. to sibling [F8]
D. to marked [Alt-J]
E. to any report line [Ctrl-F9]
F. to descendant report line [Alt-F9]
G. Search [Alt-S]
H. Go to line # [Alt-G]
I. First line [Ctrl-Home]
J. Last line [Ctrl-End]
K. Up a line [Up]
L. Down a line [Down]
M. Up a screen [PgUp]
N. Down a screen [PgDn]
N. to basis of current
IV. Edit [Alt-E]
A. Add a line
1. as a child of current [Ctrl-Enter]
2. as a sibling of current [Enter]
3. as a parent of current [Ctrl-F3]
4. as the first line
B. Copy
1. Current line to clipboard [Alt-C]
2. Current tree to clipboard [Alt-K]
3. Marked lines to clipboard [Shift-F4]
4. Marked trees to clipboard [Ctrl-F4]
C. Delete
1. Current line [Alt-D]
2. Current tree [Shift-Delete]
D. Display
1. Hide children [Alt-H]
2. Show children of current [Alt-F8]
3. Show all children
3. Select display style
E. Undo [Esc]
V. Marking [Alt-A]
A. Mark/Unmark a line [Alt-Space]
B. Reference marked lines [Alt-=]
C. Unmark all lines [Alt-U]
D. Mark if found [Ctrl-F6]
E. Search,Extract,Mark/Reference
VI. Window [Alt-W]
A. Next [F6]
B. Previous [Shift-F6]
C. Close window [Alt-F3]
D. Tile windows [Alt-Z]
E. Cascade windows [Shift-F8]
F. Size/Move window [Ctrl-F5]
G. Zoom [F5]
H. Open Clipboard
In addition, a single click of the left mouse button sets the
cursor to a line, and a double click marks or unmarks a line.
Description of commands
Edit|Add a line|As a child of current Ctrl-Enter
Creates a new line and inserts it as a child of the current line.
Script: cmAddLine
Edit|Add a line|As a sibling of current Enter
Creates a new line and inserts it as a sibling of the current
line.
Script: cmAddSibling
Edit|Add a line|as a parent of current Ctrl-F3
Creates a new line and inserts it as the parent of the current
line.
Script: cmAddBranch
Edit|Add a line|as the first line
Creates a new root line and inserts the old root into the new
root.
Script: cmAddRoot
Edit|Copy|Current line to clipboard Alt-C
Copies a line from the current window to the clip board. The
children of the line (if any) are not copied. If the clip board
is not open yet, EVOLVE! will open it.
Edit|Copy|Marked lines to clipboard Shift-F4
Copy marked lines to the current line of the clipboard.
This command will open the clipboard if necessary.
Edit|Copy|Marked trees to clipboard Ctrl-F4
Copy marked trees to the current line of the clipboard.
This command will open the clipboard if necessary.
Edit|Copy|Tree to clipboard Alt-K
Copies a subtree from the current window to the clip board.
This command will open the clipboard if necessary.
Edit|Delete|Current line Alt-D
Deletes the current line from the current window.
If the line has children, the line's parent will adopt them.
Script: cmDelLine
Edit|Delete|Current tree Shift-Delete
Erases the current subtree in the current window.
Script: cmDelTree
Edit|Display|Hide children Alt-H
Hides the children of the current line.
Script: cmHideKids
Edit|Display|Select display style
EVOLVE! provides four styles for outlines:
1. A conventional outlining style.
2. A numbered list style.
3. Blanks only.
4. Line drawing characters.
Below are examples of the four styles.
Outline Title
I. First Main topic
A. First Subtopic
1. First sub-sub-topic
i) Minor topic
a) Minor point
1) Sub-minor point
2) Another sub minor point
b) Another minor point
ii) Another minor topic
2. Second sub-sub-topic
B. Second subtopic
II. Second main topic
Outline Title
1. First Main topic
1. First Subtopic
1. First sub-sub-topic
1. Minor topic
1. Minor point
1. Sub-minor point
2. Another sub minor point
2. Another minor point
2. Another minor topic
2. Second sub-sub-topic
2. Second subtopic
2. Second main topic
Outline Title
First Main topic
First Subtopic
First sub-sub-topic
Minor topic
Minor point
Sub-minor point
Another sub minor point
Another minor point
Another minor topic
Second sub-sub-topic
Second subtopic
Second main topic
Outline Title
|-First Main topic
| |-First Subtopic
| | |-First sub-sub-topic
| | | |-Minor topic
| | | | |-Minor point
| | | | | |-Sub-minor point
| | | | | `-Another sub minor point
| | | | `-Another minor point
| | | `-Another minor topic
| | `-Second sub-sub-topic
| `-Second subtopic
`-Second main topic
Edit|Display|Show all children
Shows every line of the outline.
Script: cmShowAllKids
Edit|Display|Show children of current Alt-F8
Shows the children of the current line.
Script: cmShowKids
Edit|Undo Esc
Undoes the changes to the current line. This only has an effect
if the cursor has not moved off the line since the changes were
made.
Script: cmUndo
File|Change Directory Shift-F9
File│Change Dir brings up the Change Directory dialog box, in
which you can change the current directory.
File|Dos Shell
Shells to DOS. This allows you access to DOS without closing
EVOLVE!.
Script: cmExec
The script version of this command is slightly different. It does
not shell to DOS, rather it executes each child line as a DOS
command. When EVOLVE! executes this script command, it takes the
first word in each line and looks for an executable file of that
name. If the first token is not the name of an executable file,
EVOLVE! attempts to execute the line through the command processor
specified by the COMSPEC environment variable. This command
processor is usually 'command.com' which will process commands
like 'Dir.'
File|Exit Alt-X
The Exit command terminates this program.
File|Import ASCII File Ctrl-F8
Reads an ASCII file and transforms it into an outline. This is
the complement of Report.
Script: cmTroper
In the script, the first child is taken as the name of the file to
import.
File|Open F3
The Open command displays the Open a File dialog box. In this
dialog box you select the data file you want to use.
The "Open a File" dialog box contains:
■ an input box with a history list
■ a list box to browse the directory
■ the standard Cancel button
■ Open action button
■ an information panel that describes the
selected file
Script: cmFOpen
In the script, the first child is taken as the name of the file to
open.
File|Print Ctrl-PrtScr
Prints the outline in the current window.
Script: cmPrint
File|Print to File Shift-F7
Prints the outline descendant from the current line to a file.
Script: cmPrint2F
In the script, EVOLVE! takes the first child to be the name of the
file to print to.
File|Report to File Ctrl-F7
Prints a report to a file. The report is produced by processing
the outline. The blank display style used so no line drawing
characters, roman numerals, or numbering will be put into the
report file by EVOLVE!. EVOLVE! will look for the ":>" to define
text to print after its children. The first ":>" starts the
string that EVOLVE! appends to the end of each terminal descendant
except the last terminal descendant. The second ":>" string
defines the string that EVOLVE! appends to the end of the last
terminal descendant. A terminal descendant is the last child
itself if there are no children of the last child. Otherwise, the
terminal descendant is the terminal descendant of the last child.
Script: cmReport
File|Save F2
Saves an outline (the current line and all descendant lines) in
the current window to a data file.
File|Save As F9
Enables you to save an outline to a file name other than the one
shown as the title of the window. The outline saved will be the
current line and all descendants.
Script: cmFSaveAs
In the script, EVOLVE! takes the first child to be the name of the
file to save the outline to.
Marking|Mark if found Ctrl-F6
Marks the first line found that contains the substring you
specify.
Marking|Mark/Unmark current line Alt-Space
If the current line is unmarked, this command marks it. If the
current line is marked, this command unmarks it. Marked lines
form a set of lines that the user may reference at other
locations, or jump to with the 'Move cursor|Go to marked' menu
item.
Script: cmMark
Marking|Reference marked lines Alt-=
References all marked lines.
Script: cmReference
Marking|Search,Extract,Mark/Reference
This command performs the following steps:
1. Unmark all marks.
2. Searches for the specified text and conditions.
3. Asks the user to confirm marking/referencing the text
found.
4. Extracts the text from the line and replaces it with
"<^>".
5. If nothing is marked, the extracted text is inserted as a
child and the new child is referenced. The new child has the
correct position to be processed by the "<^>" during a
report.
6. If something has been marked, the mark is referenced. The
referenced child is positioned such that it will be processed
by the "<^>" during a report.
The text produced by a report after this process is identical to
the text produced before this process.
Marking|Unmark all lines Alt-U
Unmarks all marked lines.
Script: cmUnMarkAll
Move Cursor|Down a line Down
Select the line below as the current one.
Script: cmMoveDown
Move Cursor|Down a screen PgDn
Moves the visible portion of the window down the height of the
window. The command moves the cursor also to keep it visible in
the window.
Move Cursor|First line Ctrl-Home
Goes to the first line in the outline.
Script: cmFirstLine
Move Cursor|Go to line # Alt-G
Moves to the selected line number.
Script: cmGoToLine
In the script, EVOLVE! looks for the line number at the beginning
text of the first child.
Move Cursor|Last line Ctrl-End
Goes to the last line in the outline.
Script: cmLastLine
Move Cursor|Search Alt-S
Search will open a dialog box where you can enter text. EVOLVE!
will then search in the direction you specify for the next
occurrence of that text and make that occurrence the current line.
Move Cursor|Up a line Up
Selects the line above as the current line.
Script: cmMoveUp
Move Cursor|Up a screen PgUp
This command moves the visible portion of the window up the height
of the window. The command moves the cursor also to keep it
visible in the window.
Move Cursor|to basis of current
Goes to the Basis. When a line is referenced, only one instance
shows the children explicitly. The instance that shows the
children is the basis.
Script: cmGoToBasis
Move Cursor|to child F4
Select one of the current line's children as the current line.
Script: cmGoToKid
In the script, EVOLVE! looks for the a number at the beginning of
the instruction's first child to indicate which of the current
line's children will become the next current line. If the number
is 0 then the first child will become the current line. In
general, if the number is N then the N+1 child will become the
current line.
Move Cursor|to marked Alt-J
Selects one of the Marked lines as the current line. This is a
good way to see the marked lines. The lines are shown in a
scrollable menu. Each line begins with the line number that the
text appears at. The text that follows the line number has the
<^> characters replaced with the appropriate text.
Script: cmGoToMark
In the script, EVOLVE! looks for the a number at the beginning of
the instruction's first child to indicate which of the marked
line's will become the next current line. If the number is 0 then
the first marked line will become the current line. In general,
if the number is N then the N+1 marked line will become the
current line.
Move Cursor|to parent F7
Selects one of the current line's parents as the current line.
This is a good way to see the parent lines. The lines are shown
in a scrollable menu. Each line begins with the line number that
the text appears at. The text that follows the line number has
the <^> characters replaced with the appropriate text.
Script: cmGoToParent
In the script, EVOLVE! looks for the a number at the beginning of
the instruction's first child to indicate which of the current
line's parents will become the next current line. Each referenced
line will have multiple appearances and one parent per appearance.
If the number is 0 then the first parent will become the current
line. In general, if the number is N then the N+1 parent will
become the current line.
Move Cursor|to report line Ctrl-F9
Displays the report text and enables you to move to the outline
entry that corresponds to the reported line. This is a good way
to see the source code as reported. The lines are shown in a
scrollable menu.
Script: cmGoToRepLine
In the script, EVOLVE! looks for the a number at the beginning of
the instruction's first child to indicate which report line will
become the next current line.
Move Cursor|to descendant report line Alt-F9
Displays the report text and enables you to move to the outline
entry that corresponds to the reported line descendant from the
current line. This is a good way to see the source code as
reported. The lines are shown in a scrollable menu. This command
is faster than 'Move Cursor| to report line' because it processes
fewer reported lines.
Script: cmGoToDescRepLine
In the script, EVOLVE! looks for the a number at the beginning of
the instruction's first child to indicate which report line will
become the next current line.
Move Cursor|to sibling F8
Selects one of the current line's siblings as the current line.
This is a good way to see the sibling lines. The lines are shown
in a scrollable menu. Each line begins with the line number that
the text appears at. The text that follows the line number has
the <^> characters replaced with the appropriate text.
Script: cmGoToSibling
In the script, EVOLVE! looks for the a number at the beginning of
the instruction's first child to indicate which of the current
line's siblings will become the next current line. If the number
is 0 then the first sibling will become the current line. In
general, if the number is N then the N+1 sibling will become the
current line.
Relocate|Line from clipboard Shift-F2
Takes a line from the clip board and inserts it in the current
window. If the line has children, the line's parent will adopt
them. If the clip board is not open yet, EVOLVE! will open it.
Relocate|Line to clipboard Shift-F1
Cuts a line from the current window and inserts it in the clip
board. If the line has children, the line's parent will adopt
them. If the clip board is not open yet, EVOLVE! will open it.
Relocate|Marked lines to under current Shift-F3
Relocates marked lines to under current.
Script: cmMoveMarkedLines
Relocate|Sort|Ascending Grey-Plus
Sorts the siblings, under one branch, in ascending order.
Script: cmOrderAscend
Relocate|Sort|Descending Grey-Minus
Sorts the siblings, under one branch, in descending order.
Script: cmOrderDescend
Relocate|Tree Down Ctrl-PgDn
Moves the current subtree up or down by switching its position
with the sibling below.
Script: cmMoveTreeDn
Relocate|Tree from clipboard Ctrl-F2
Removes the current subtree from the clip board and inserts it
under the current line in the current window.
Relocate|Tree left a level Ctrl-Left
Moves the current line and all its descendants such that its
grandparent becomes its new parent.
Script: cmMoveTreeLeft
Relocate|Tree right a level Ctrl-Right
Moves the current line and all its descendants such that its
nearest sibling above it becomes its new parent.
Script: cmMoveTreeRight
Relocate|Tree to clipboard Ctrl-F1
Removes a subtree from the current window and inserts it under the
current line in the clip board. EVOLVE! opens the clip board if
it needs to do so.
Relocate|Tree up Ctrl-PgUp
Moves the current subtree up or down by switching its position
with the sibling above.
Script: cmMoveTreeUp
Window|Cascade windows Shift-F8
Stacks all file viewers on the desktop.
Window|Close window Alt-F3
Closes the active window.
You can also click the Close box in the upper right corner to
close a window.
Window|Next F6
Cycles forwards through the windows on the desktop.
Window|Open Clipboard
Opens a window for the clip board.
Window|Previous Shift-F6
Cycles forwards through the windows on the desktop.
Window|Size/Move window Ctrl-F5
Changes the size or position of the active window.
====
Size
====
If you press Shift while you use the arrow keys, you can change
the size of the active window. Once you've adjusted its size or
position, press Enter.
If a window has a Resize corner, you can drag that corner to
resize the window.
======
Move
======
When you choose Window│Size/Move, the active window moves in
response to the arrow keys. Once you've moved a window to where
you want it, press Enter.
You can also move a window by dragging its title bar with the
mouse.
Window|Tile Alt-Z
Tiles all windows on the desktop.
Window|Zoom F5
Resizes the active window to the maximum size. If the window is
already zoomed, you can choose this command to restore it to its
previous size.
You can also double-click anywhere on the window's title bar
(except where an icon appears) to zoom or unzoom the window.
Menu items sorted by hotkey
Menu Item HotKey
---------------------------------------- ---------------
Edit|Add a line|as the first line
Edit|Display|Select display style
Move Cursor|to basis of current
Window|Open Clipboard
Marking|Reference marked lines Alt-=
Edit|Copy|Current line to clipboard Alt-C
Edit|Delete|Current line Alt-D
Window|Close window Alt-F3
Edit|Display|Show children of current Alt-F8
Move Cursor|to descendant report line Alt-F9
Execute as script program Alt-F10
Move Cursor|Go to line # Alt-G
Edit|Display|Hide children Alt-H
Move Cursor|to marked Alt-J
Edit|Copy|Tree to clipboard Alt-K
Move Cursor|Search Alt-S
Marking|Mark/Unmark current line Alt-Space
Marking|Unmark all lines Alt-U
File|Exit Alt-X
Window|Tile Alt-Z
Move Cursor|Last line Ctrl-End
Edit|Add a line|As a child of current Ctrl-Enter
Relocate|Tree to clipboard Ctrl-F1
Relocate|Tree from clipboard Ctrl-F2
Edit|Add a line|as a parent of current Ctrl-F3
Edit|Copy|Marked trees to clipboard Ctrl-F4
Window|Size/Move window Ctrl-F5
Marking|Mark if found Ctrl-F6
File|Report to file Ctrl-F7
File|Import ASCII file Ctrl-F8
Move cursor|to report line Ctrl-F9
Move cursor|First line Ctrl-Home
Relocate|Tree left a level Ctrl-Left
Relocate|Tree down Ctrl-PgDn
Relocate|Tree up Ctrl-PgUp
File|Print Ctrl-PrtSc
Relocate|Tree right a level Ctrl-Right
Move cursor|Down a line Down
Edit|Add a line|As a sibling of current Enter
Edit|Undo Esc
File|Save F2
File|Open F3
Move cursor|To child F4
Window|Zoom F5
Window|Next F6
Move cursor|To parent F7
Move cursor|To sibling F8
File|Save As F9
Relocate|Sort|Descending Grey-Minus
Relocate|Sort|Ascending Grey-Plus
Move cursor|Down a screen PgDn
Move cursor|Up a screen PgUp
Edit|Delete|Current tree Shift-Delete
Relocate|Line to clipboard Shift-F1
Relocate|Line from clipboard Shift-F2
Relocate|Marked lines to under current Shift-F3
Edit|Copy|Marked lines to clipboard Shift-F4
Window|Previous Shift-F6
File|Print to file Shift-F7
Window|Cascade windows Shift-F8
File|Change directory Shift-F9
Move cursor|Up a line Up
License Agreement
Richard H. Smith
7040 Wick Lane
Derwood, MD 20855
(301) 977-4166
Please use copy, and distribute EVOLVE!. This program is
distributed as Shareware.
Definition of Shareware
Shareware distribution gives users a chance to try software before
buying it. If you try a Shareware program and continue using it,
you are expected to register. Individual programs differ on
details -- some request registration while others require it, some
specify a maximum trial period. With registration, you get
anything from the simple right to continue using the software to
an updated program with printed manual.
Copyright laws apply to both Shareware and commercial software,
and the copyright holder retains all rights, with a few specific
exceptions as stated below. Shareware authors are accomplished
programmers, just like commercial authors, and the programs are of
comparable quality. (In both cases, there are good programs and
bad ones!) The main difference is in the method of distribution.
The author specifically grants the right to copy and distribute
the software, either to all and sundry or to a specific group. For
example, some authors require written permission before a
commercial disk vendor may copy their Shareware.
Shareware is a distribution method, not a type of software. You
should find software that suits your needs and pocketbook, whether
it's commercial or Shareware. The Shareware system makes fitting
your needs easier, because you can try before you buy. And because
the overhead is low, prices are low also. Shareware has the
ultimate money-back guarantee -- if you don't use the product, you
don't pay for it.
Disclaimer - Agreement
Users of EVOLVE! must accept this disclaimer of warranty: "EVOLVE!
is supplied as is. The author disclaims all warranties, expressed
or implied, including, without limitation, the warranties of
merchantability and of fitness for any purpose.
The author assumes no liability for damages, direct or
consequential, which may result from the use of EVOLVE!. EVOLVE!
is a "shareware program" and is provided at no charge to the user
for evaluation. Feel free to share it with your friends, but
please do not give it away altered or as part of another system.
The essence of "user-supported" software is to provide personal
computer users with quality software without high prices, and yet
to provide incentive for programmers to continue to develop new
products. If you find this program useful and find that you are
using EVOLVE! and continue to use EVOLVE! after a reasonable trial
period, you must make a registration payment of $29.00 plus $5.00
shipping and handling to Software Smiths. The $29.00 registration
fee will license one copy for use on any one computer at any one
time. If you find value in EVOLVE! but can not afford the $29.00,
you may obtain a low priority registration by sending me a letter
telling me that you can not afford to pay the $29.00 fee now, but
that you intend to pay it in the future when you can afford it.
You must treat this software just like a book. An example is that
this software may be used by any number of people and may be
freely moved from one computer location to another, so long as
there is no possibility of it being used at one location while
it's being used at another. Just as a book cannot be read by two
different persons at the same time. The $5.00 shipping and
handling will pay for material Software Smiths will mail to you
upon registration.
Commercial users of EVOLVE! must register and pay for their copies
of EVOLVE! within 30 days of first use or their license is
withdrawn. Site-License arrangements may be made by contacting
Software Smiths.
Anyone distributing EVOLVE! for any kind of remuneration must
first contact Software Smiths at the address at the beginning of
this appendix for authorization. This authorization will be
automatically granted to distributors recognized by the (ASP) as
adhering to its guidelines for shareware distributors, and such
distributors may begin offering EVOLVE! immediately (However
Software Smiths must still be advised so that the distributor can
be kept up-to-date with the latest version of EVOLVE!.).
You are encouraged to pass a copy of EVOLVE! along to your friends
for evaluation. Please encourage them to register their copy if
they find that they can use it. All registered users will receive
a copy of the latest version of the EVOLVE! system.
Benefits of registering
Software Smiths will provide the following
1. If you register as a user and pay $5.00 shipping and
handling, Software Smiths will send you the next version of
EVOLVE!. Your registration will apply to this version mailed
directly to you.
2. The registered version of the software will not have a
registration notice at the start up.
3. Software Smiths will send you a printed user's guide.
4. Software Smiths will notify you of any significant bugs
found.
5. Software Smiths will extend to you the first opportunity
to purchase related programs. We currently plan to develop
versions for OS/2 and Microsoft Windows.
6. Software Smiths will incorporate your ideas and feedback
into the continued development of their products.
7. You may call or write to Software Smiths about any problem
you have with EVOLVE! and we will do our best to remedy the
situation.
How To Register
To register, use a text editor to fill out the form in the file
"REGISTER.DOC". This form is shown on the next page:
Registration Form
Mail to: Richard H. Smith
Software Smiths
7040 Wick Lane
Derwood, MD 20855-1963
Name:
Address:
City: State: Zip code:
Product Name: Version: Release:
What is your occupation?
What do you use this software for?
What do you like most about our software?
What do you like least about our software?
What do you like most about our documentation?
What do you like least about our documentation?
What is the hardware configuration off your computer?
CPU: [] 8088 [] 80286 [] 80386 [] 80486
Size Hard Disk: Type of Modem:
3 1/2" Disk Drive [] 5 1/4" Disk Drive []
What type of software do you use?
Operating System:
Graphical user interface:
Programming Languages:
Where did you get our software from?
Check one:
[] I have enclosed a check that includes the $29.00
registration fee.
[] I can not afford the $29.00 now, but I will pay it when I
can.
Check one:
[] I have enclosed a check that includes the $5.00 shipping
and handling fee.
[] I do not want Software Smiths to mail me anything.
ASP Ombudsman Statement
This program is produced by a member of the Association of
Shareware Professionals (ASP). ASP wants to make sure that the
shareware principle works for you. If you are unable to resolve a
shareware-related problem with an ASP member by contacting the
member directly, ASP may be able to help. The ASP Ombudsman can
help you resolve a dispute or problem with an ASP member, but does
not provide technical support for members' products. Please write
to the ASP Ombudsman at 545 Grover Road, Muskegon, MI 49442 or
send a CompuServe message via CompuServe Mail to ASP Ombudsman
70007,3536.
About the Author
Richard H. Smith, 7040 Wick Lane, Derwood, MD 20855
(301) 977-4166
Objective: An opportunity to perform systems analysis, software
engineering and training.
Operating Systems: MS-DOS, UNIX, VMS.
Languages: Pascal, Prolog, Oracle, SQL-Plus, SLAM-II
Applications: Wordperfect, Lotus 123, Lotus Freelance, Corel
Draw.
Hardware: IBM-PC, Unisys, Vax.
Professional Experience:
February 1991 - Present: Self Employed. Developed "EVOLVE!" a
structure editor that empowers programmers to implement source
code changes more efficiently than a text editor. This structure
editor can produce source code in any language.
June 1988-February 1991: Research Analyst and Software Engineer,
Analytic Services Inc. Systems Analyst, software engineer, and
instructor for the following products:
Integrated SCOPE-MARGI (ISM). Used structured analysis and
structured design to integrate two decision support systems
(SCOPE & MARGI). Designed and developed a new capability for
ISM that uses an event driven, object oriented user
interface.
Material Handling Equipment Decision Support System
(MHE-DSS). Used structured analysis and structured design to
develop this program for calculating the performance of MHE,
and the Air Forces requirements for MHE. I coded the MHE-DSS
in Pascal. The knowledgebase in the MHE-DSS was derived from
a simulation I coded in SLAM-II.
Joint Service Research, Development and Acquisition Plan
management information system. I coded this in Oracle and
SQL-Plus on a Unisys 5000.
Method for analyzing Reliability Goals and Investments
(MARGI), a decision support system for calculating the
benefits in combat capability from aircraft reliability
improvements. Used structured analysis and structured design
to develop. Written in Turbo Pascal and Turbo Prolog.
October 1984-June 1988 Acquisition Program Manager, United States
Air Force Tactical Reconnaissance System Program Office. Managed
the development and acquisition of tactical reconnaissance
systems.
Education: B.S. Engineering Physics, 1984, University of Colorado
at Boulder.
